﻿<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title></title>
<link rel="stylesheet" type="text/css" href="../css/common.css" media="all" />
<link rel="stylesheet" type="text/css" href="../css/article.css" media="all" />
</head>
<body>
<div id="w3h_body">
  <div class="body_content">
    <!-- toc begin -->
    <h1 class="title">SD9028:ECMAScript 的数据类型运算符 typeof 在各浏览器中存在兼容性问题</h1>
    <ul class="toc">
      <li><a href="#standard_reference">标准参考</a> <span>•</span></li>
      <li><a href="#description">问题描述</a> <span>•</span></li>
      <li><a href="#influence">造成的影响</a> <span>•</span></li>
      <li><a href="#impacted_browsers">受影响的浏览器</a> <span>•</span></li>
      <li><a href="#analysis_of_issues">问题分析</a> <span>•</span></li>
      <li><a href="#solutions">解决方案</a> <span>•</span></li>
      <li><a href="#see_also">参见</a></li>
    </ul>
    <!-- toc end -->
    <div id="w3h_content">
      <!-- content begin -->
      <address class="author">作者：钱宝坤</address>
      <h2 id="standard_reference">标准参考</h2>
      <p>“typeof” 为 JavaScript 中用来实现数据类型判断的一元运算符，一元运算符还包括： &quot;delete&quot; &quot;++&quot; &quot;--&quot; &quot;+&quot; &quot;-&quot; &quot;~&quot; &quot;!&quot; 等。</p>
    <p>ECMAScript5.0 规范中对 'typeof val' 表达式的执行步骤如下：</p>
        <ol>
          <li>计算一元表达式的值；</li>
            <li>如果步骤一的计算结果为引用类型：
               <ol>
                  <li>如果 IsUnresolvableReference(val)<sup>1</sup> 的执行结果 true ，则返回最终结果 “undefined”，表达式计算结束；</li>
                  <li>执行 GetValue(val) <sup>2</sup>。</li>
               </ol>
            </li>
            <li>根据下表返回最终结果： </li>
        </ol>
      <table class="compare" title="typeof Operator Results">
        <caption>
        typeof Operator Results
        </caption>
        <tr>
          <th>Type of val</th>
          <th>Result</th>
        </tr>
        <tr>
          <td>Undefined</td>
          <td>&quot;undefined&quot;</td>
        </tr>
        <tr>
          <td>Null</td>
          <td>&quot;object&quot;</td>
        </tr>
        <tr>
          <td>Boolean</td>
          <td>&quot;boolean&quot;</td>
        </tr>
        <tr>
          <td>Number</td>
          <td>&quot;number&quot;</td>
        </tr>
        <tr>
          <td>String</td>
          <td>&quot;string&quot;</td>
        </tr>
        <tr>
          <td>Object (native and does not implement [[Call]])</td>
          <td>&quot;object&quot;</td>
        </tr>
        <tr>
          <td>Object (native or host and does implement [[Call]])</td>
          <td>&quot;function&quot;</td>
        </tr>
        <tr>
          <td>Object (host and does not implement [[Call]])</td>
          <td>Implementation-defined except may not be &quot;undefined&quot;, &quot;boolean&quot;, &quot;number&quot;, or &quot;string&quot;.</td>
        </tr>
      </table>
      <p class="comment"> 注1：IsUnresolvableReference(val) 函数指的是 JavaScript 引擎内核应实现的处理方法，而不是 JavaScript·语法层面的内置函数或方法。<br />
      ·参考资料：ECMAScript 5.0中的 <a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf">8.7 The Reference Specification Type</a> ，如果  val 的值没有被定义则返回 true，否则返回 false; </p>
      <p class="comment"> 注2：GetValue (val)，指的是 JavaScript 引擎内核应实现的处理方法，而不是 JavaScript·语法层面的内置函数或方法。<br />
      参考资料：ECMAScript 5.0中的 <a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf">8.7.1 GetValue (V)</a> </p>
      <ul class="comment">
        <li>如果 val 不是引用类型，返回 val；</li>
        <li>调用 getBase(val) 方法，返回 val 的基本对象类型；</li>
        <li>如果步骤二返回 null，抛出 ReferenceError 异常；</li>
        <li>调用步骤二返回值的 [Get] 方法，通过 GetPropertyName(val) 求原型名称；</li>
        <li>返回第四步的值。</li>
      </ul>
      <p> typeof 运算符返回代表被检测对象类型的<strong>字符串值</strong>。有关 typeof 的参考资料请查阅：ECMAScript 5.0 中的 <a href="http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf">11.4.3 The typeof Operator</a> ECMAScript 3.0中的 <a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf"> 11.4.3 The typeof Operator</a>。 </p>
      <h2 id="description">问题描述</h2>
      <p>typeof 运算符存在兼容性问题，例如：</p>
      <ul>
        <li>&quot; typeof document.getElementById &quot; 的结果在 IE 中为 “object”，在其他浏览器中为 “function”；</li>
        <li> &quot; typeof new RegExp()  &quot; 或 &quot; typeof /\w/ &quot; 语句对正则表达式实例对象的识别结果在 Chrome Safari 中为 &quot;function&quot; 而不是 &quot;object&quot;。</li>
      </ul>

      <h2 id="influence">造成的影响</h2>
      <p>typeof 运算符在各浏览器之间存在兼容性问题，这将造成依赖此运算符获得的数据在不同浏览器中可能不同从而影响后续代码的执行。</p>
      <h2 id="impacted_browsers">受影响的浏览器</h2>
      <table class="list">
        <tr>
          <th> IE6 IE7 IE8</th>
          <th>&nbsp;</th>
        </tr>
      </table>
      <h2 id="analysis_of_issues">问题分析</h2>
      <p>JavaScript 的本地对象里有共六种基本数据类型，其中有五种原始类型：Number String Boolean Null Undefined，其它的都是复合数据类型 Object。对象是一种复合数据类型，是一个无序的属性集合，每个属性都有自己的名字和值。ECMAScript 可以识别的对象包括：本地对象（native Object）和宿主对象（host Object），以及一个本地对象的子分类——内置对象（ECMAScript 5.0 <a href="http://www.ecma-international.org/publications/files/ECMA-ST-ARCH/ECMA-262,%203rd%20edition,%20December%201999.pdf">4.3.7 Built-in Object</a>）。本地对象属于 JavaScript  语言范围，而宿主对象由宿主环境提供，例如，document 对象和 DOM 节点。 </p>
      <p> 分析并运行一下代码： </p>
<pre>&lt;div id=&quot;info&quot;&gt;&lt;/div&gt;
window.onload = function(){
  var a;
  document.getElementById("info").innerHTML = "typeof undefined == " + (typeof undefined) +
  "&lt;br/&gt; typeof a === " + (typeof a)+
  "&lt;br/&gt; typeof 1 === " + (typeof 1) +
  "&lt;br/&gt; typeof \"hello\" === " + (typeof "hello") +
  "&lt;br/&gt; typeof true === " + (typeof true) +
  "&lt;br/&gt; typeof null === " + (typeof null) +
  "&lt;br/&gt; typeof new Date() === " + (typeof new Date()) +
  "&lt;br/&gt; typeof document === " + (typeof document) +
  "&lt;br/&gt; typeof (new Date()).getDate === " + (typeof (new Date()).getDate) +
  "&lt;br/&gt; typeof parseInt === " + (typeof parseInt) +
  "&lt;br/&gt;&lt;span style=\"color:red\"&lt; typeof NodeList === " + (typeof document.getElementsByTagName("*")) +"&lt;/span&lt;" +
  "&lt;br/&gt;&lt;span style=\"color:red\"&gt; typeof new RegExp === " + (typeof new RegExp())+"&lt;/span&gt;" +
  "&lt;br/&gt;&lt;span style=\"color:red\"&gt; typeof window.open === " + (typeof window.open)+"&lt;/span&gt;" +
  "&lt;br/&gt;&lt;span style=\"color:red\"&gt; typeof document.write === " + (typeof document.write)+"&lt;span&gt;"+
  "&lt;br/&gt;&lt;span style=\"color:red\"&gt; typeof document.getElementById === " + (typeof document.getElementById)+"&lt;/span&gt;";
}
</pre>
      <p>在各浏览器中的运行结果如下：</p>
      <table class="compare">
        <tr>
          <th>IE6 IE7 IE8</th>
          <th>FireFox Chrome Opera </th>
          <th>Safari</th>
        </tr>
        <tr>
          <td>typeof undefined === &quot;undefined&quot;<br />
            typeof a === &quot;undefined&quot;<br />
            typeof 1 === &quot;number&quot;<br />
            typeof &quot;hello&quot; === &quot;string&quot;<br />
            typeof true   === &quot;boolean&quot;<br />
            typeof null === &quot;object&quot;<br />
            typeof new Date() === &quot;object&quot;<br />
            typeof   document === &quot;object&quot;<br />
            typeof (new Date()).getDate === &quot;function&quot;<br />
            typeof  parseInt === &quot;function&quot;<br />
            typeof  NodeList === &quot;object&quot; <br />
            <span style="color:red">            typeof new RegExp() === &quot;object&quot;<br />
            typeof window.open ===   &quot;object&quot;<br />
            typeof document.write === &quot;object&quot;<br />
          typeof document.getElementById === &quot;object&quot;</span></td>
          <td> typeof undefined === &quot;undefined&quot;<br />
            typeof a === &quot;undefined&quot;<br />
            typeof 1 === &quot;number&quot;<br />
            typeof &quot;hello&quot; === &quot;string&quot;<br />
            typeof true === &quot;boolean&quot;<br />
            typeof null === &quot;object&quot;<br />
            typeof new Date() === &quot;object&quot;<br />
            typeof document === &quot;object&quot;<br />
            typeof (new Date()).getDate === &quot;function&quot;<br />
            typeof parseInt === &quot;function&quot;<br />
            typeof  NodeList === &quot;object&quot; <br />
            <span style="color:red">typeof new RegExp() === &quot;function&quot;<br />
            typeof window.open === &quot;function&quot;<br />
            typeof document.write === &quot;function&quot;<br />
          typeof document.getElementById === &quot;function&quot;</span></td>
          <td>typeof undefined === &quot;undefined&quot;<br />
typeof a === &quot;undefined&quot;<br />
typeof 1 === &quot;number&quot;<br />
typeof &quot;hello&quot; === &quot;string&quot;<br />
typeof true === &quot;boolean&quot;<br />
typeof null === &quot;object&quot;<br />
typeof new Date() === &quot;object&quot;<br />
typeof document === &quot;object&quot;<br />
typeof (new Date()).getDate === &quot;function&quot;<br />
typeof parseInt === &quot;function&quot;<br />
<span style="color:red">typeof  NodeList === &quot;function&quot; <br />
typeof new RegExp() === &quot;function&quot;<br />
typeof window.open === &quot;function&quot;<br />
typeof document.write === &quot;function&quot;<br />
typeof document.getElementById === &quot;function&quot;</span></td>
        </tr>
      </table>
      <p>从运行结果截图可知黑色文字部分是在各浏览器中相同的 typeof 运行结果，红色文字部分是 IE 与其他浏览器不同的。</p>
      <p>可见在所有浏览器中 typeof 对 ECMAScript 中除去 RegExp 对象实例外，其他基本数据类型以及他们的实例识别无兼容性问题。但对 DOM 和 BOM 复合数据类型的识别存在兼容性问题，例如上例中的最后三项，它们是 BOM、DOM 接口中 window 和 document 对象的函数，不属于 ECMAScript 规定的内置类型。</p>
      <h3>首先分析 NodeList 类型识别问题：</h3>
      <p> NodeList 类型在标准 DOM 中描述为一个接口(interface)，他是规范定义内容，在浏览器中是由浏览器内核语言负责实现这个对象（通常是C语言），这个实现后 NodeList 对象将被绑定到 ECMAScript 语言对象中，以便通过浏览器脚本语言访问以及操作他。</p>
      <p> 他们的绑定关系可参见：<a href="http://www.w3.org/TR/DOM-Level-2-Core/ecma-script-binding.html">DOM-Level-2-Core Appendix E: ECMAScript Language Binding</a> 与 <a href="http://www.w3.org/TR/DOM-Level-2-HTML/ecma-script-binding.html">DOM-Level-2-HTML Appendix D: ECMAScript Language Binding</a></p>
      <p>在规范的绑定关系描述中，NodeList 对象所绑定的 ECMAScript 类型为 “object”。这说明使用 typeof 语句检测 NodeList 类型结果应为 “object” 而不是上例中的 &quot;function&quot;。这是 Safari 的 javaScriptCore 脚本引擎的一个实现 Bug。</p>
      <p class="comment">【注】：虽然 Safari 中可以使用 NodeList(0) 这样的语法得到 Node ，他看起来像是个函数调用，但是 IE 中同样也支持 &quot;括号&quot; 语法得到指定索引值的元素，而 IE 却正确的返回的 NodeList 类型为 &quot;function&quot;。所以 Safari 的这种 &quot;括号&quot; 语法仅能看做他为了兼容 IE 而单独为 NodeList 扩展出的特殊用法，并不能说明 NodeList 是 Function。</p>
      <h3>其次分析 RegExp 对象实例的类型识别问题：</h3>
      <p>ECMAScript 5.0 typeof Operator Results
     表中明确说明：原生对象或者宿主对象并且可以被执行的是 Fucntion 类型，也就是内情内部实现了[[Call]] 的对象，而原生的不能被执行的是 Object 类型（见标准参考中表格）。</p>
      <p>一个正则表达式对象实例在 IE &nbsp;(包括 IE10 预览版) 都是不能执行的，如：&quot;(new RegExp('\\d'))(1)&quot; 或 &quot;(/\d/)(1)&quot; 语句<strong>均会报错</strong>，而同样的语句在 Firefox Safari Chrome Opera 中<strong>均可执行</strong>。</p>
      <p>正则表达式对象实例可以被括号运算符符执行并能传入参数，这表明该对象实例依据 ECMAScript 规范标准，实现了内部实现了 [[Call]] 。</p>
      <p>Chrome 和 Safari 中依据 ECMAScript typeof Operator Results
      中规定，在 typeof 表达式判断时，带有 [[Call]] 实现的正则表达式对象实例中 [[Call]] 被检测到，结果输出为 &quot;function&quot; 字符串。</p>
      <p>此外还可以根据源浏览器的源码实现得出旁证。</p>
      <p>如，在 Safari 的 javaScriptCore 引擎实现内，Operations.cpp 文件实现了typeof 功能，RegExpObject.cpp 文件实现了正则表达式对象，他们关键部分如下：</p>
<pre>
// Operations.cpp
JSValue jsTypeStringForValue(CallFrame* callFrame, JSValue v)
{
    if (v.isUndefined())
        return jsNontrivialString(callFrame, "undefined");
    if (v.isBoolean())
        return jsNontrivialString(callFrame, "boolean");
    if (v.isNumber())
        return jsNontrivialString(callFrame, "number");
    if (v.isString())
        return jsNontrivialString(callFrame, "string");
    <span class="hl_4">if (v.isObject())</span> {
        // Return "undefined" for objects that should be treated
        // as null when doing comparisons.
        if (asObject(v)-&gt;structure()-&gt;typeInfo().masqueradesAsUndefined())
            return jsNontrivialString(callFrame, "undefined");
        CallData callData;
        <span class="hl_4">if (asObject(v)-&gt;getCallData(callData) != CallTypeNone)</span>
            <span class="hl_4">return jsNontrivialString(callFrame, "function");</span>
    }
    return jsNontrivialString(callFrame, "object");
}
</pre>
<pre>
// RegExpObject.cpp
CallType RegExpObject::getCallData(CallData&amp; callData)
{
    callData.native.function = callRegExpObject;
    <span class="hl_4">return CallTypeHost</span>;
}
</pre>

      <p>Operations.cpp 文件中，判断如果是对象则进入分支，查找当前对象是否是伪装为 undefined 的，如果是则返回 ”undefined“ 字符串；然后判断执行 getCallData 方法后返回的值是否为非 CallTypeNone，如果判断成立则返回 &quot;function&quot; 字符串。</p>
      <p>正则表达式对象的 getCallData 方法的返回值在 RegExpObject.cpp 文件中给出，是 CallTypeHost 而非 CallTypeNone，导致了判断语句的表达式结果为 true，返回 &quot;function&quot; 字符串。      </p>
      <p>而 Firefox Opera<sup>1</sup> 浏览器中，在为正则表达式对象实例实现  [[Call]] 后，为了不引起混淆，没有严格遵循 ECMAScript typeof Operator Results
        中规定，他们将带有 [[Call]] 实现的正则表达式对象实例中的 [[Call]] 实现判断步骤修正为未实现  [[Call]] 的情况，因此结果与 IE 一致，输出为 &quot;object&quot; 字符串。      </p>
      <p class="comment">【注】：Chrome 的 V8 引擎对此处实现情况与 Safari 的 javaScriptCore 引擎类似，Firefox 的 SpiderMonkey 引擎与之实现相反，均不再给出具体引擎实现代码的分析，有兴趣的读者可以自行查找相关源文件查看。另外，由于 Opera 浏览器并不开源，我们无法得知这个问题在他源代码中的具体实现方法，此处对 Opera 行为的描述基于以上分析的逻辑推理，视同其与 Firefox 的实现思路一致。</p>
      <h3>然后分析 DOM 和 BOM 复合数据类型的识别问题：</h3>
      <p>在 IE6 IE7 IE8 <sup>1</sup> 浏览器中，按照 ECMAScript 规范实现的是名为 JScript 的脚本引擎，他是独立于浏览器系统之外的。JScript 调用 DOM 或 BOM 方法需要通过 windows 系统中的 COM 机制。浏览器中的 DOM 与 BOM 对象和相关必须通过第三方 COM 机制将数据转换到  JScript 脚本引擎内进行相关调用，因此原本 Function 类型的数据在  COM 机制转换后统一变成了 Object 类型。</p>
      <p class="comment">【注】：微软在 IE9 中已经将 JScript 引擎集成到浏览器核心内，故 IE9 Beta 版本中已不存在这个问题，可参考：<a href="http://blogs.msdn.com/b/ie/archive/2010/09/02/dup-exploring-ie9-s-enhanced-dom-capabilities.aspx">Exploring IE9's Enhanced DOM Capabilities</a></p>
      <p>浏览器内核与 JScript 引擎关系模型如图：</p>
      <p><img src="../../tests/SD9028/01.png" alt="IE9" width="780" height="333" /></p>
      <p>而其他浏览中，脚本引擎是处于浏览器核心实现之内，DOM 的相关实现都是按照现行 DOM 规范中的 DOM 继承和与 ECMAScript 绑定关系实现的；BOM 由各自浏览器自行实现或者按照 HTML5 草案规范基于 ECMAScript 规范实现。这使得这些浏览器内 DOM BOM 与 JavaScript 通信设计上是在一套规范体系内，JavaScript 的 typeof 运算可以正确获得对应类型的计算结果。</p>
      <p>他们的绑定关系可参见：<a href="http://www.w3.org/TR/DOM-Level-2-Core/ecma-script-binding.html">DOM-Level-2-Core Appendix E: ECMAScript Language Binding</a> 与 <a href="http://www.w3.org/TR/DOM-Level-2-HTML/ecma-script-binding.html">DOM-Level-2-HTML Appendix D: ECMAScript Language Binding</a></p>
      <h2 id="solutions">解决方案</h2>
      <p>由于以上几点的各浏览器实现差异，我们建议用户在充分了解 typeof 运算符含义时再使用。</p>
      <p>下面的代码封装了名为 realtypeof 的方法，用来消除已知的各浏览器之间原生 typeof 运算符差异，仅作参考：</p>
<pre>function realtypeof(source){
  return (source === undefined)
    ? "undefined"
    : ("object" === typeof source)
      ? (/function/i.test( source + "" ))
        ? "function"
        : "object"
      : (source.constructor == RegExp || !(source.constructor instanceof Function))
        ? "object"
        : typeof source;
}
</pre>
      <h2 id="see_also">参见</h2>
      <h3>知识库</h3>
      <ul class="see_also">
        <li><a href="#">...</a></li>
      </ul>
      <h3>相关问题</h3>
      <ul class="see_also">
        <li><a href="#">...</a></li>
      </ul>
      <div class="appendix">
        <h2>测试环境</h2>
        <table class="list">
          <tr>
            <th>操作系统版本:</th>
            <td>Windows 7 Ultimate build 7600</td>
          </tr>
          <tr>
            <th>浏览器版本:</th>
            <td>
             IE6<br />
              IE7<br />
              IE8<br />
              Firefox 3.6.10<br />
              Chrome 7.0.517.8 dev<br />
              Safari 5.0.2<br />
              Opera 10.62
          </tr>
          <tr>
            <th>测试页面:</th>
            <td><a href="../../tests/SD9028/typeof.html">typeof.html</a></td>
          </tr>
          <tr>
            <th>本文更新时间:</th>
            <td>2010-09-14</td>
          </tr>
        </table>
        <h2>关键字</h2>  
        <!-- keywords begin -->
        <p>typeof object function</p>
        <!-- keywords end -->
      </div>
      <!-- content end -->
    </div>
  </div>
</div>
</body>
</html>
